home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / bash_114.zip / bash-1.14.2 / print_cmd.c < prev    next >
C/C++ Source or Header  |  1994-06-29  |  18KB  |  828 lines
  1. /* print_command -- A way to make readable commands from a command tree. */
  2. /* Copyright (C) 1989 Free Software Foundation, Inc.
  3.  
  4. This file is part of GNU Bash, the Bourne Again SHell.
  5.  
  6. Bash is free software; you can redistribute it and/or modify it under
  7. the terms of the GNU General Public License as published by the Free
  8. Software Foundation; either version 1, or (at your option) any later
  9. version.
  10.  
  11. Bash is distributed in the hope that it will be useful, but WITHOUT ANY
  12. WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14. for more details.
  15.  
  16. You should have received a copy of the GNU General Public License along
  17. with Bash; see the file COPYING.  If not, write to the Free Software
  18. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  19.  
  20. #include <stdio.h>
  21.  
  22. #if defined (HAVE_VARARGS_H)
  23. #  include <varargs.h>
  24. #endif
  25.  
  26. #if defined (HAVE_STRING_H)
  27. #  include <string.h>
  28. #else /* !HAVE_STRING_H */
  29. #  include <strings.h>
  30. #endif /* !HAVE_STRING_H */
  31.  
  32. #include "shell.h"
  33. #include "y.tab.h"
  34. #include "stdc.h"
  35. #include "builtins/common.h"
  36.  
  37. #if defined (__GNUC__) || defined (ardent)
  38. extern int printf __P((const char *, ...));    /* Yuck.  Double yuck. */
  39. #endif
  40.  
  41. static int indentation = 0;
  42. static int indentation_amount = 4;
  43.  
  44. static void cprintf (), newline (), indent (), the_printed_command_resize ();
  45. static void semicolon ();
  46.  
  47. static void make_command_string_internal ();
  48. static void command_print_word_list ();
  49. static void print_case_clauses ();
  50. static void print_redirection_list ();
  51. static void print_redirection ();
  52.  
  53. static void print_for_command ();
  54. #if defined (SELECT_COMMAND)
  55. static void print_select_command ();
  56. #endif
  57. static void print_group_command ();
  58. static void print_case_command ();
  59. static void print_while_command ();
  60. static void print_until_command ();
  61. static void print_until_or_while ();
  62. static void print_if_command ();
  63. static void print_function_def ();
  64.  
  65. #define PRINTED_COMMAND_GROW_SIZE 1024
  66.  
  67. char *the_printed_command = (char *)NULL;
  68. int the_printed_command_size = 0;
  69. int command_string_index = 0;
  70.  
  71. /* Non-zero means the stuff being printed is inside of a function def. */
  72. static int inside_function_def = 0;
  73. static int skip_this_indent = 0;
  74.  
  75. /* The depth of the group commands that we are currently printing.  This
  76.    includes the group command that is a function body. */
  77. static int group_command_nesting = 0;
  78.  
  79. /* Print COMMAND (a command tree) on standard output. */
  80. void
  81. print_command (command)
  82.      COMMAND *command;
  83. {
  84.   command_string_index = 0;
  85.   printf ("%s", make_command_string (command));
  86. }
  87.  
  88. /* Make a string which is the printed representation of the command
  89.    tree in COMMAND.  We return this string.  However, the string is
  90.    not consed, so you have to do that yourself if you want it to
  91.    remain around. */
  92. char *
  93. make_command_string (command)
  94.      COMMAND *command;
  95. {
  96.   command_string_index = 0;
  97.   make_command_string_internal (command);
  98.   return (the_printed_command);
  99. }
  100.  
  101. /* The internal function.  This is the real workhorse. */
  102. static void
  103. make_command_string_internal (command)
  104.      COMMAND *command;
  105. {
  106.   if (!command)
  107.     cprintf ("");
  108.   else
  109.     {
  110.       if (skip_this_indent)
  111.     skip_this_indent--;
  112.       else
  113.     indent (indentation);
  114.  
  115.       if (command->flags & CMD_WANT_SUBSHELL)
  116.     cprintf ("( ");
  117.  
  118.       if (command->flags & CMD_INVERT_RETURN)
  119.     cprintf ("! ");
  120.  
  121.       switch (command->type)
  122.     {
  123.     case cm_for:
  124.       print_for_command (command->value.For);
  125.       break;
  126.  
  127. #if defined (SELECT_COMMAND)
  128.     case cm_select:
  129.       print_select_command (command->value.Select);
  130.       break;
  131. #endif
  132.  
  133.     case cm_case:
  134.       print_case_command (command->value.Case);
  135.       break;
  136.  
  137.     case cm_while:
  138.       print_while_command (command->value.While);
  139.       break;
  140.  
  141.     case cm_until:
  142.       print_until_command (command->value.While);
  143.       break;
  144.  
  145.     case cm_if:
  146.       print_if_command (command->value.If);
  147.       break;
  148.  
  149.     case cm_simple:
  150.       print_simple_command (command->value.Simple);
  151.       break;
  152.  
  153.     case cm_connection: 
  154.  
  155.       skip_this_indent++;
  156.       make_command_string_internal (command->value.Connection->first);
  157.  
  158.       switch (command->value.Connection->connector)
  159.         {
  160.         case '&':
  161.         case '|':
  162.           {
  163.         char c = command->value.Connection->connector;
  164.         cprintf (" %c", c);
  165.         if (c != '&' || command->value.Connection->second)
  166.           {
  167.             cprintf (" ");
  168.             skip_this_indent++;
  169.           }
  170.           }
  171.           break;
  172.  
  173.         case AND_AND:
  174.           cprintf (" && ");
  175.           if (command->value.Connection->second)
  176.         skip_this_indent++;
  177.           break;
  178.  
  179.         case OR_OR:
  180.           cprintf (" || ");
  181.           if (command->value.Connection->second)
  182.         skip_this_indent++;
  183.           break;
  184.     
  185.         case ';':
  186.           cprintf (";");
  187.  
  188.           if (inside_function_def)
  189.         cprintf ("\n");
  190.           else
  191.         {
  192.           cprintf (" ");
  193.           if (command->value.Connection->second)
  194.             skip_this_indent++;
  195.         }
  196.           break;
  197.  
  198.         default:
  199.           cprintf ("print_command: bad connector `%d'",
  200.                command->value.Connection->connector);
  201.           break;
  202.         }
  203.  
  204.       make_command_string_internal (command->value.Connection->second);
  205.       break;
  206.       
  207.     case cm_function_def:
  208.       print_function_def (command->value.Function_def);
  209.       break;
  210.  
  211.     case cm_group:
  212.       print_group_command (command->value.Group);
  213.       break;
  214.  
  215.     default:
  216.       programming_error ("print_command: bad command type `%d'", command->type);
  217.       break;
  218.     }
  219.  
  220.       if (command->flags & CMD_WANT_SUBSHELL)
  221.     cprintf (" )");
  222.  
  223.       if (command->redirects)
  224.     print_redirection_list (command->redirects);
  225.     }
  226. }
  227.  
  228. static void
  229. _print_word_list (list, separator, pfunc)
  230.      WORD_LIST *list;
  231.      char *separator;
  232.      VFunction *pfunc;
  233. {
  234.   while (list)
  235.     {
  236.       (*pfunc) ("%s", list->word->word);
  237.       list = list->next;
  238.       if (list)
  239.     (*pfunc) ("%s", separator);
  240.     }
  241. }
  242.  
  243. void print_word_list (list, separator)
  244.      WORD_LIST *list;
  245.      char *separator;
  246. {
  247.   _print_word_list (list, separator, (VFunction *)printf);
  248. }
  249.  
  250. static void
  251. command_print_word_list (list, separator)
  252.      WORD_LIST *list;
  253.      char *separator;
  254. {
  255.   _print_word_list (list, separator, cprintf);
  256. }
  257.  
  258. static void
  259. print_for_command (for_command)
  260.      FOR_COM *for_command;
  261. {
  262.   cprintf ("for %s in ", for_command->name->word);
  263.   command_print_word_list (for_command->map_list, " ");
  264.   cprintf (";");
  265.   newline ("do\n");
  266.   indentation += indentation_amount;
  267.   make_command_string_internal (for_command->action);
  268.   semicolon ();
  269.   indentation -= indentation_amount;
  270.   newline ("done");
  271. }
  272.  
  273. #if defined (SELECT_COMMAND)
  274. static void
  275. print_select_command (select_command)
  276.      SELECT_COM *select_command;
  277. {
  278.   cprintf ("select %s in ", select_command->name->word);
  279.   command_print_word_list (select_command->map_list, " ");
  280.   cprintf (";");
  281.   newline ("do\n");
  282.   indentation += indentation_amount;
  283.   make_command_string_internal (select_command->action);
  284.   semicolon ();
  285.   indentation -= indentation_amount;
  286.   newline ("done");
  287. }
  288. #endif /* SELECT_COMMAND */
  289.  
  290. static void
  291. print_group_command (group_command)
  292.      GROUP_COM *group_command;
  293. {
  294.   group_command_nesting++;
  295.   cprintf ("{ ");
  296.  
  297.   if (!inside_function_def)
  298.     skip_this_indent++;
  299.   else
  300.     {
  301.       /* This is a group command { ... } inside of a function
  302.      definition, and should be handled as a `normal' group
  303.      command, using the current indentation. */
  304.       cprintf ("\n");
  305.       indentation += indentation_amount;
  306.     }
  307.  
  308.   make_command_string_internal (group_command->command);
  309.  
  310.   cprintf ("\n");
  311.  
  312.   if (group_command_nesting)
  313.     {
  314.       indentation -= indentation_amount;
  315.       indent (indentation);
  316.       if (!indentation)
  317.     cprintf (" ");
  318.     }
  319.       
  320.   cprintf ("}");
  321.   group_command_nesting--;
  322. }
  323.  
  324. static void
  325. print_case_command (case_command)
  326.      CASE_COM *case_command;
  327. {
  328.   cprintf ("case %s in ", case_command->word->word);
  329.   if (case_command->clauses)
  330.     print_case_clauses (case_command->clauses);
  331.   newline ("esac");
  332. }
  333.  
  334. static void
  335. print_case_clauses (clauses)
  336.      PATTERN_LIST *clauses;
  337. {
  338.   indentation += indentation_amount;
  339.   while (clauses)
  340.     {
  341.       newline ("");
  342.       command_print_word_list (clauses->patterns, " | ");
  343.       cprintf (")\n");
  344.       indentation += indentation_amount;
  345.       make_command_string_internal (clauses->action);
  346.       indentation -= indentation_amount;
  347.       newline (";;");
  348.       clauses = clauses->next;
  349.     }
  350.   indentation -= indentation_amount;
  351. }
  352.  
  353. static void
  354. print_while_command (while_command)
  355.      WHILE_COM *while_command;
  356. {
  357.   print_until_or_while (while_command, "while");
  358. }
  359.  
  360. static void
  361. print_until_command (while_command)
  362.      WHILE_COM *while_command;
  363. {
  364.   print_until_or_while (while_command, "until");
  365. }
  366.  
  367. static void
  368. print_until_or_while (while_command, which)
  369.      WHILE_COM *while_command;
  370.      char *which;
  371. {
  372.   cprintf ("%s ", which);
  373.   skip_this_indent++;
  374.   make_command_string_internal (while_command->test);
  375.   semicolon ();
  376.   cprintf (" do\n");    /* was newline ("do\n"); */
  377.   indentation += indentation_amount;
  378.   make_command_string_internal (while_command->action);
  379.   indentation -= indentation_amount;
  380.   semicolon ();
  381.   newline ("done");
  382. }
  383.  
  384. static void
  385. print_if_command (if_command)
  386.      IF_COM *if_command;
  387. {
  388.   cprintf ("if ");
  389.   skip_this_indent++;
  390.   make_command_string_internal (if_command->test);
  391.   semicolon ();
  392.   cprintf (" then\n");
  393.   indentation += indentation_amount;
  394.   make_command_string_internal (if_command->true_case);
  395.   indentation -= indentation_amount;
  396.  
  397.   if (if_command->false_case)
  398.     {
  399.       semicolon ();
  400.       newline ("else\n");
  401.       indentation += indentation_amount;
  402.       make_command_string_internal (if_command->false_case);
  403.       indentation -= indentation_amount;
  404.     }
  405.   semicolon ();
  406.   newline ("fi");
  407. }
  408.  
  409. void
  410. print_simple_command (simple_command)
  411.      SIMPLE_COM *simple_command;
  412. {
  413.   command_print_word_list (simple_command->words, " ");
  414.  
  415.   if (simple_command->redirects)
  416.     {
  417.       cprintf (" ");
  418.       print_redirection_list (simple_command->redirects);
  419.     }
  420. }
  421.  
  422. static void
  423. print_redirection_list (redirects)
  424.      REDIRECT *redirects;
  425. {
  426.   while (redirects)
  427.     {
  428.       print_redirection (redirects);
  429.       redirects = redirects->next;
  430.       if (redirects)
  431.     cprintf (" ");
  432.     }
  433. }
  434.  
  435. static void
  436. print_redirection (redirect)
  437.      REDIRECT *redirect;
  438. {
  439.   int kill_leading = 0;
  440.   int redirector = redirect->redirector;
  441.   WORD_DESC *redirectee = redirect->redirectee.filename;
  442.   int redir_fd = redirect->redirectee.dest;
  443.  
  444.   switch (redirect->instruction)
  445.     {
  446.     case r_output_direction:
  447.       if (redirector != 1)
  448.     cprintf ("%d", redirector);
  449.       cprintf (">%s", redirectee->word);
  450.       break;
  451.  
  452.     case r_input_direction:
  453.       if (redirector != 0)
  454.     cprintf ("%d", redirector);
  455.       cprintf ("<%s", redirectee->word);
  456.       break;
  457.  
  458.     case r_inputa_direction:    /* Redirection created by the shell. */
  459.       cprintf ("&");
  460.       break;
  461.  
  462.     case r_appending_to:
  463.       if (redirector != 1)
  464.     cprintf ("%d", redirector);
  465.       cprintf (">>%s", redirectee->word);
  466.       break;
  467.  
  468.     case r_deblank_reading_until:
  469.       kill_leading++;
  470.       /* ... */
  471.     case r_reading_until:
  472.       if (redirector != 0)
  473.     cprintf ("%d", redirector);
  474.       /* If the here document delimiter is quoted, single-quote it. */
  475.       if (redirect->redirectee.filename->quoted)
  476.         {
  477.           char *x;
  478.           x = single_quote (redirect->here_doc_eof);
  479.       cprintf ("<<%s%s\n", kill_leading? "-" : "", x);
  480.           free (x);
  481.         }
  482.       else
  483.     cprintf ("<<%s%s\n", kill_leading? "-" : "", redirect->here_doc_eof);
  484.       cprintf ("%s%s",
  485.            redirect->redirectee.filename->word, redirect->here_doc_eof);
  486.       break;
  487.  
  488.     case r_duplicating_input:
  489.       cprintf ("%d<&%d", redirector, redir_fd);
  490.       break;
  491.  
  492.     case r_duplicating_output:
  493.       cprintf ("%d>&%d", redirector, redir_fd);
  494.       break;
  495.  
  496.     case r_duplicating_input_word:
  497.       cprintf ("%d<&%s", redirector, redirectee->word);
  498.       break;
  499.  
  500.     case r_duplicating_output_word:
  501.       cprintf ("%d>&%s", redirector, redirectee->word);
  502.       break;
  503.  
  504.     case r_close_this:
  505.       cprintf ("%d>&-", redirector);
  506.       break;
  507.  
  508.     case r_err_and_out:
  509.       cprintf (">&%s", redirectee->word);
  510.       break;
  511.  
  512.     case r_input_output:
  513.       if (redirector != 1)
  514.     cprintf ("%d", redirector);
  515.       cprintf ("<>%s", redirectee->word);
  516.       break;
  517.  
  518.     case r_output_force:
  519.       if (redirector != 1)
  520.     cprintf ("%d", redirector);
  521.       cprintf (">|%s", redirectee->word);
  522.       break;
  523.     }
  524. }
  525.  
  526. static void
  527. reset_locals ()
  528. {
  529.   inside_function_def = 0;
  530.   indentation = 0;
  531. }
  532.  
  533. static void
  534. print_function_def (func)
  535.      FUNCTION_DEF *func;
  536. {
  537.   cprintf ("function %s () \n", func->name->word);
  538.   add_unwind_protect (reset_locals, 0);
  539.  
  540.   indent (indentation);
  541.   cprintf ("{ \n");
  542.  
  543.   inside_function_def++;
  544.   indentation += indentation_amount;
  545.  
  546.   if (func->command->type == cm_group)
  547.     make_command_string_internal (func->command->value.Group->command);
  548.   else
  549.     make_command_string_internal (func->command);
  550.     
  551.   remove_unwind_protect ();
  552.   indentation -= indentation_amount;
  553.   inside_function_def--;
  554.  
  555.   newline ("}");
  556. }
  557.  
  558. /* Return the string representation of the named function.
  559.    NAME is the name of the function.
  560.    COMMAND is the function body.  It should be a GROUP_COM.
  561.    MULTI_LINE is non-zero to pretty-print, or zero for all on one line.
  562.   */
  563. char *
  564. named_function_string (name, command, multi_line)
  565.      char *name;
  566.      COMMAND *command;
  567.      int multi_line;
  568. {
  569.   char *result;
  570.   int old_indent = indentation, old_amount = indentation_amount;
  571.  
  572.   command_string_index = 0;
  573.  
  574.   if (name && *name)
  575.     cprintf ("%s ", name);
  576.  
  577.   cprintf ("() ");
  578.  
  579.   if (!multi_line)
  580.     {
  581.       indentation = 1;
  582.       indentation_amount = 0;
  583.     }
  584.   else
  585.     {
  586.       cprintf ("\n");
  587.       indentation += indentation_amount;
  588.     }
  589.  
  590.   inside_function_def++;
  591.  
  592.   if (multi_line)
  593.     cprintf ("{ \n");
  594.   else
  595.     cprintf ("{ ");
  596.  
  597.   if (command->type == cm_group)
  598.     make_command_string_internal (command->value.Group->command);
  599.   else
  600.     make_command_string_internal (command);
  601.  
  602.   indentation = old_indent;
  603.   indentation_amount = old_amount;
  604.   inside_function_def--;
  605.  
  606.   newline ("}");
  607.  
  608.   result = the_printed_command;
  609.  
  610.   if (!multi_line)
  611.     {
  612. #if 0
  613.       register int i;
  614.       for (i = 0; result[i]; i++)
  615.     if (result[i] == '\n')
  616.       {
  617.         strcpy (result + i, result + i + 1);
  618.         --i;
  619.       }
  620. #else
  621.       if (result[2] == '\n')    /* XXX -- experimental */
  622.         strcpy (result + 2, result + 3);
  623. #endif
  624.     }
  625.  
  626.   return (result);
  627. }
  628.  
  629. static void
  630. newline (string)
  631.      char *string;
  632. {
  633.   cprintf ("\n");
  634.   indent (indentation);
  635.   if (string && *string)
  636.     cprintf ("%s", string);
  637. }
  638.  
  639. static void
  640. indent (amount)
  641.      int amount;
  642. {
  643.   while (amount-- > 0)
  644.     cprintf (" ");
  645. }
  646.  
  647. static void
  648. semicolon ()
  649. {
  650.   if (command_string_index > 0 && the_printed_command[command_string_index - 1] == '&')
  651.     return;
  652.   cprintf (";");
  653. }
  654.  
  655. #if !defined (HAVE_VARARGS_H)
  656. /* How to make the string. */
  657. static void
  658. cprintf (format, arg1, arg2)
  659.      char *format, *arg1, *arg2;
  660. {
  661.   register char *s;
  662.   char char_arg[2], *argp, *args[2];
  663.   int arg_len, c, arg_index;
  664.  
  665.   args[0] = arg1;
  666.   args[1] = arg2;
  667.  
  668.   arg_len = strlen (format);
  669.   the_printed_command_resize (arg_len + 1);
  670.  
  671.   char_arg[1] = '\0';
  672.   s = format;
  673.   while (s && *s)
  674.     {
  675.       int free_argp = 0;
  676.       c = *s++;
  677.       if (c != '%' || !*s)
  678.     {
  679.       argp = s;
  680.       arg_len = 1;
  681.     }
  682.       else
  683.     {
  684.       c = *s++;
  685.       switch (c)
  686.         {
  687.         case '%':
  688.           char_arg[0] = c;
  689.           argp = char_arg;
  690.           arg_len = 1;
  691.           break;
  692.  
  693.         case 's':
  694.           argp = (char *)args[arg_index++];
  695.           arg_len = strlen (argp);
  696.           break;
  697.  
  698.         case 'd':
  699.           argp = itos (pointer_to_int (args[arg_index]));
  700.           arg_index++;
  701.           arg_len = strlen (argp);
  702.           free_argp = 1;
  703.           break;
  704.  
  705.         case 'c':
  706.           char_arg[0] = pointer_to_int (args[arg_index]);
  707.           arg_index++;
  708.           argp = char_arg;
  709.           arg_len = 1;
  710.           break;
  711.  
  712.         default:
  713.           programming_error ("cprintf: bad `%%' argument (%c)", c);
  714.         }
  715.     }
  716.       if (argp)
  717.     {
  718.       the_printed_command_resize (arg_len + 1);
  719.       FASTCOPY (argp, the_printed_command + command_string_index, arg_len);
  720.       command_string_index += arg_len;
  721.       if (free_argp)
  722.         free (argp);
  723.     }
  724.     }
  725.  
  726.   the_printed_command[command_string_index] = '\0';
  727. }
  728.  
  729. #else /* We have support for varargs. */
  730.  
  731. /* How to make the string. */
  732. static void
  733. cprintf (va_alist)
  734.      va_dcl
  735. {
  736.   register char *s;
  737.   char *control, char_arg[2], *argp;
  738.   int digit_arg, arg_len, c;
  739.   va_list args;
  740.  
  741.   va_start (args);
  742.   control = va_arg (args, char *);
  743.  
  744.   arg_len = strlen (control);
  745.   the_printed_command_resize (arg_len + 1);
  746.  
  747.   char_arg[1] = '\0';
  748.   s = control;
  749.   while (s && *s)
  750.     {
  751.       int free_argp = 0;
  752.       c = *s++;
  753.       if (c != '%' || !*s)
  754.     {
  755.       argp = s - 1;
  756.       arg_len = 1;
  757.     }
  758.       else
  759.     {
  760.       c = *s++;
  761.       switch (c)
  762.         {
  763.         case '%':
  764.           char_arg[0] = c;
  765.           argp = char_arg;
  766.           arg_len = 1;
  767.           break;
  768.  
  769.         case 's':
  770.           argp = va_arg (args, char *);
  771.           arg_len = strlen (argp);
  772.           break;
  773.  
  774.         case 'd':
  775.           digit_arg = va_arg (args, int);
  776.           argp = itos (digit_arg);
  777.           arg_len = strlen (argp);
  778.           free_argp = 1;
  779.           break;
  780.  
  781.         case 'c':
  782.           char_arg[0] = va_arg (args, int);
  783.           argp = char_arg;
  784.           arg_len = 1;
  785.           break;
  786.  
  787.         default:
  788.           programming_error ("cprintf: bad `%%' argument (%c)", c);
  789.         }
  790.     }
  791.  
  792.       if (argp)
  793.     {
  794.       the_printed_command_resize (arg_len + 1);
  795.       FASTCOPY (argp, the_printed_command + command_string_index, arg_len);
  796.       command_string_index += arg_len;
  797.       if (free_argp)
  798.         free (argp);
  799.     }
  800.     }
  801.  
  802.   the_printed_command[command_string_index] = '\0';
  803. }
  804. #endif /* HAVE_VARARGS_H */
  805.  
  806. /* Ensure that there is enough space to stuff LENGTH characters into
  807.    THE_PRINTED_COMMAND. */
  808. static void
  809. the_printed_command_resize (length)
  810.      int length;
  811. {
  812.   if (!the_printed_command)
  813.     {
  814.       the_printed_command_size = length + 1;
  815.       the_printed_command = xmalloc (the_printed_command_size);
  816.       command_string_index = 0;
  817.     }
  818.   else if ((command_string_index + length) >= the_printed_command_size)
  819.     {
  820.       int new;
  821.       new = command_string_index + length + 1;
  822.       new = new + 2 * PRINTED_COMMAND_GROW_SIZE - 1;
  823.       new -= new % PRINTED_COMMAND_GROW_SIZE;
  824.       the_printed_command_size = new;
  825.       the_printed_command = xrealloc (the_printed_command, the_printed_command_size);
  826.     }
  827. }
  828.